package cn.edu.xjtu.android.emoji_warfare_android.engine.worker;

import java.util.Collection;

import android.util.Log;
import cn.edu.xjtu.android.emoji_warfare_android.engine.BaseEngine;
import cn.edu.xjtu.android.emoji_warfare_android.engine.SyncLinkedList;

/**
 * DelayedWorker<br>
 * 延迟处理器，用于取代旧物理引擎的延迟发射功能，技能系统等<br>
 * 主要用法：<br>
 * 1.创建DelayedOperation<br>
 * 2.设置好延迟和对应操作<br>
 * 3.使用add或addAll添加到DelayedWorker中<br>
 * 4.用resume方法启动Worker
 * 
 * @author bill
 *
 */
public class DelayedWorker extends BaseWorker {
    /**
     * 默认动作刷新时间间<br>
     * 由于延迟动作延迟时间任意，因此最好为1<br>
     * 如果性能要求过高，可以增大该数值
     */
    public final static long DEFAULT_REFRESH_INTERVAL = 1;

    /**
     * 所有的延迟操作
     */
    private SyncLinkedList<DelayedOperation> operations;

    /**
     * 构建一个延迟处理器
     * 
     * @param engine
     *            引擎
     * @param interval
     *            循环间隔
     */
    public DelayedWorker(BaseEngine engine, long interval) {
        super(engine, interval);
        operations = new SyncLinkedList<DelayedOperation>();
    }

    public DelayedWorker(BaseEngine engine) {
        this(engine, DEFAULT_REFRESH_INTERVAL);
    }

    @Override
    void round() {
        super.round();
    }

    @Override
    public void resume() {
        super.resume();
    }

    @Override
    public void pause() {
        super.pause();
    }

    /**
     * 添加一个延迟操作
     * 
     * @param opt
     *            目标操作
     * @return 总是返回true
     */
    public boolean add(DelayedOperation opt) {
        Log.d("Delay", "adding " + opt.getClass().getName());
        return operations.add(opt);
    }

    /**
     * 添加许多延迟操作
     * 
     * @param collection
     *            操作容器，如数组
     * @return 成功返回真
     */
    public boolean addAll(Collection<? extends DelayedOperation> collection) {
        return operations.addAll(collection);
    }

    /**
     * 遍历一次所有的延迟操作
     */
    @Override
    public void run() {
        // 获取当前时间
        long now = engine.clock();
        for (int i = 0; i < operations.size(); i++) {
            // 遍历
            DelayedOperation o = operations.get(i);
            // 如果已经到时间，则运行一次
            if (now - o.last >= o.getDelayMillis()) {
                // 如果需要移除，则删除该操作，否则重置时间
                if (o.run()) {
                    operations.remove(o);
                } else {
                    o.last = now;
                }
            }
        }
    }

}
